{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-title"
    ]
   },
   "source": [
    "# Fully-Connected Neural Nets\n",
    "In the previous homework you implemented a fully-connected two-layer neural network on CIFAR-10. \n",
    "\n",
    "The implementation was simple but not very modular since the loss and gradient were computed in a single monolithic function. \n",
    "\n",
    "This is manageable for a simple two-layer network, but would become impractical as we move to bigger models. \n",
    "\n",
    "Ideally we want to build networks using a more modular design so that we can implement different layer types in isolation and then snap them together into models with different architectures.\n",
    "\n",
    "在之前的作业中，您在CIFAR-10上实现了一个完全连接的两层神经网络。\n",
    "\n",
    "实现简单，但不是很模块化，因为损失和梯度计算在一个单一的monolithic功能。\n",
    "\n",
    "对于一个简单的两层网络来说，这是可以管理的，但是当我们转向更大的模型时，这就变得不切实际了。\n",
    "\n",
    "理想情况下，我们希望使用更模块化的设计来构建网络，这样我们就可以独立地实现不同的层类型，然后将它们整合到具有不同架构的模型中。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "source": [
    "In this exercise we will implement fully-connected networks using a more modular approach. \n",
    "\n",
    "For each layer we will implement a `forward` and a `backward` function. \n",
    "\n",
    "The `forward` function will receive inputs, weights, and other parameters and will return both an output and a `cache` object storing data needed for the backward pass, like this:\n",
    "\n",
    "在本练习中，我们将使用更模块化的方法实现全连接网络。\n",
    "\n",
    "对于每一层，我们将实现`forward`和`backward`功能。\n",
    "\n",
    "`forward`函数将接收输入、权重和其他参数，并返回一个输出和一个`cache`对象，存储后向传递所需的数据，如下所示:\n",
    "\n",
    "```python\n",
    "def layer_forward(x, w):\n",
    "  \"\"\" Receive inputs x and weights w \"\"\"\n",
    "  # Do some computations ...\n",
    "  z = # ... some intermediate value\n",
    "  # Do some more computations ...\n",
    "  out = # the output\n",
    "   \n",
    "  cache = (x, w, z, out) # Values we need to compute gradients\n",
    "   \n",
    "  return out, cache\n",
    "```\n",
    "\n",
    "The backward pass will receive upstream derivatives and the `cache` object, and will return gradients with respect to the inputs and weights, like this:\n",
    "\n",
    "反向传递将接收上游导数和`cache`对象，并返回与输入和权重相关的梯度，如下所示:\n",
    "\n",
    "```python\n",
    "def layer_backward(dout, cache):\n",
    "  \"\"\"\n",
    "  Receive dout (derivative of loss with respect to outputs) and cache,\n",
    "  and compute derivative with respect to inputs.\n",
    "  接收dout(损失对输出的导数)和缓存，并计算对输入的导数。\n",
    "  \"\"\"\n",
    "  # Unpack cache values\n",
    "  x, w, z, out = cache\n",
    "  \n",
    "  # Use values in cache to compute derivatives\n",
    "  dx = # Derivative of loss with respect to x\n",
    "  dw = # Derivative of loss with respect to w\n",
    "  \n",
    "  return dx, dw\n",
    "```\n",
    "\n",
    "After implementing a bunch of layers this way, we will be able to easily combine them to build classifiers with different architectures.\n",
    "\n",
    "以这种方式实现了一堆层之后，我们将能够轻松地将它们组合起来，以构建具有不同架构的分类器。\n",
    "\n",
    "In addition to implementing fully-connected networks of arbitrary depth, we will also explore different update rules for optimization, and introduce Dropout as a regularizer and Batch/Layer Normalization as a tool to more efficiently optimize deep networks.\n",
    "\n",
    "除了实现任意深度的全连通网络，我们还将探索不同的优化更新规则，并引入Dropout作为正则化器和Batch/Layer Normalization工具来更有效地优化深度网络。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "run the following from the cs231n directory and try again:\n",
      "python setup.py build_ext --inplace\n",
      "You may also need to restart your iPython kernel\n"
     ]
    }
   ],
   "source": [
    "# As usual, a bit of setup\n",
    "from __future__ import print_function\n",
    "import time\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from cs231n.classifiers.fc_net import *\n",
    "from cs231n.data_utils import get_CIFAR10_data\n",
    "from cs231n.gradient_check import eval_numerical_gradient, eval_numerical_gradient_array\n",
    "from cs231n.solver import Solver\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "# for auto-reloading external modules\n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "def rel_error(x, y):\n",
    "  \"\"\" returns relative error \"\"\"\n",
    "  return np.max(np.abs(x - y) / (np.maximum(1e-8, np.abs(x) + np.abs(y))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('X_train: ', (49000, 3, 32, 32))\n",
      "('y_train: ', (49000,))\n",
      "('X_val: ', (1000, 3, 32, 32))\n",
      "('y_val: ', (1000,))\n",
      "('X_test: ', (1000, 3, 32, 32))\n",
      "('y_test: ', (1000,))\n"
     ]
    }
   ],
   "source": [
    "# Load the (preprocessed) CIFAR10 data.\n",
    "\n",
    "data = get_CIFAR10_data()\n",
    "for k, v in list(data.items()):\n",
    "  print(('%s: ' % k, v.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Affine layer: foward\n",
    "Open the file `cs231n/layers.py` and implement the `affine_forward` function.\n",
    "\n",
    "Once you are done you can test your implementaion by running the following:\n",
    "\n",
    "一旦你做了，你可以测试你的实现通过运行以下:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing affine_forward function:\n",
      "difference:  9.769847728806635e-10\n"
     ]
    }
   ],
   "source": [
    "# Test the affine_forward function\n",
    "\n",
    "num_inputs = 2\n",
    "input_shape = (4, 5, 6)\n",
    "output_dim = 3\n",
    "\n",
    "input_size = num_inputs * np.prod(input_shape)\n",
    "weight_size = output_dim * np.prod(input_shape)\n",
    "\n",
    "x = np.linspace(-0.1, 0.5, num=input_size).reshape(num_inputs, *input_shape)\n",
    "w = np.linspace(-0.2, 0.3, num=weight_size).reshape(np.prod(input_shape), output_dim)\n",
    "b = np.linspace(-0.3, 0.1, num=output_dim)\n",
    "\n",
    "out, _ = affine_forward(x, w, b)\n",
    "correct_out = np.array([[ 1.49834967,  1.70660132,  1.91485297],\n",
    "                        [ 3.25553199,  3.5141327,   3.77273342]])\n",
    "\n",
    "# Compare your output with ours. The error should be around e-9 or less.\n",
    "print('Testing affine_forward function:')\n",
    "print('difference: ', rel_error(out, correct_out))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Affine layer: backward\n",
    "Now implement the `affine_backward` function and test your implementation using numeric gradient checking.\n",
    "\n",
    "现在实现`affine_backward`函数，并使用数值梯度检查测试您的实现。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing affine_backward function:\n",
      "dx error:  5.399100368651805e-11\n",
      "dw error:  9.904211865398145e-11\n",
      "db error:  2.4122867568119087e-11\n"
     ]
    }
   ],
   "source": [
    "# Test the affine_backward function\n",
    "np.random.seed(231)\n",
    "x = np.random.randn(10, 2, 3)\n",
    "w = np.random.randn(6, 5)\n",
    "b = np.random.randn(5)\n",
    "dout = np.random.randn(10, 5)\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(lambda x: affine_forward(x, w, b)[0], x, dout)\n",
    "dw_num = eval_numerical_gradient_array(lambda w: affine_forward(x, w, b)[0], w, dout)\n",
    "db_num = eval_numerical_gradient_array(lambda b: affine_forward(x, w, b)[0], b, dout)\n",
    "\n",
    "_, cache = affine_forward(x, w, b)\n",
    "dx, dw, db = affine_backward(dout, cache)\n",
    "\n",
    "# The error should be around e-10 or less\n",
    "print('Testing affine_backward function:')\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "print('dw error: ', rel_error(dw_num, dw))\n",
    "print('db error: ', rel_error(db_num, db))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ReLU activation: forward\n",
    "Implement the forward pass for the ReLU activation function in the `relu_forward` function and test your implementation using the following:\n",
    "\n",
    "在`relu_forward`函数中实现ReLU激活函数的前向传播，并使用以下方法测试您的实现:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing relu_forward function:\n",
      "difference:  4.999999798022158e-08\n"
     ]
    }
   ],
   "source": [
    "# Test the relu_forward function\n",
    "\n",
    "x = np.linspace(-0.5, 0.5, num=12).reshape(3, 4)\n",
    "\n",
    "out, _ = relu_forward(x)\n",
    "correct_out = np.array([[ 0.,          0.,          0.,          0.,        ],\n",
    "                        [ 0.,          0.,          0.04545455,  0.13636364,],\n",
    "                        [ 0.22727273,  0.31818182,  0.40909091,  0.5,       ]])\n",
    "\n",
    "# Compare your output with ours. The error should be on the order of e-8\n",
    "print('Testing relu_forward function:')\n",
    "print('difference: ', rel_error(out, correct_out))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ReLU activation: backward\n",
    "Now implement the backward pass for the ReLU activation function in the `relu_backward` function and test your implementation using numeric gradient checking:\n",
    "\n",
    "现在在`relu_backward`中实现ReLU激活函数的后向传播，并使用数值梯度检查来测试你的实现:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing relu_backward function:\n",
      "dx error:  3.2756349136310288e-12\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "x = np.random.randn(10, 10)\n",
    "dout = np.random.randn(*x.shape)\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(lambda x: relu_forward(x)[0], x, dout)\n",
    "\n",
    "_, cache = relu_forward(x)\n",
    "dx = relu_backward(dout, cache)\n",
    "\n",
    "# The error should be on the order of e-12\n",
    "print('Testing relu_backward function:')\n",
    "print('dx error: ', rel_error(dx_num, dx))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "## Inline Question 1: \n",
    "\n",
    "We've only asked you to implement ReLU, but there are a number of different activation functions that one could use in neural networks, each with its pros and cons. \n",
    "\n",
    "In particular, an issue commonly seen with activation functions is getting zero (or close to zero) gradient flow during backpropagation. \n",
    "\n",
    "Which of the following activation functions have this problem? \n",
    "\n",
    "If you consider these functions in the one dimensional case, what types of input would lead to this behaviour?\n",
    "\n",
    "我们只要求您实现ReLU，但是在神经网络中可以使用许多不同的激活函数，每种函数都有其优缺点。\n",
    "\n",
    "特别是，激活函数的一个常见问题是在反向传播期间获得零(或接近零)梯度流。\n",
    "\n",
    "下列哪个激活函数有此问题?\n",
    "\n",
    "如果在一维情况下考虑这些函数，什么类型的输入将导致这种行为?\n",
    "\n",
    "1. Sigmoid\n",
    "2. ReLU\n",
    "3. Leaky ReLU\n",
    "\n",
    "## Answer:\n",
    "[FILL THIS IN]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# \"Sandwich\" layers\n",
    "There are some common patterns of layers that are frequently used in neural nets. For example, affine layers are frequently followed by a ReLU nonlinearity. \n",
    "\n",
    "To make these common patterns easy, we define several convenience layers in the file `cs231n/layer_utils.py`.\n",
    "\n",
    "在神经网络中有一些常用的层模式。例如，仿射层后面经常跟一个ReLU非线性。\n",
    "\n",
    "为了简化这些常见模式，我们在文件`cs231n/layer_utils.py`中定义了几个方便的层。\n",
    "\n",
    "For now take a look at the `affine_relu_forward` and `affine_relu_backward` functions, and run the following to numerically gradient check the backward pass:\n",
    "\n",
    "现在让我们看一下`affine_relu_forward`和`affine_relu_backward`函数，并运行以下代码来对后向遍历进行数值梯度检查:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing affine_relu_forward and affine_relu_backward:\n",
      "dx error:  6.750562121603446e-11\n",
      "dw error:  8.162015570444288e-11\n",
      "db error:  7.826724021458994e-12\n"
     ]
    }
   ],
   "source": [
    "from cs231n.layer_utils import affine_relu_forward, affine_relu_backward\n",
    "np.random.seed(231)\n",
    "x = np.random.randn(2, 3, 4)\n",
    "w = np.random.randn(12, 10)\n",
    "b = np.random.randn(10)\n",
    "dout = np.random.randn(2, 10)\n",
    "\n",
    "out, cache = affine_relu_forward(x, w, b)\n",
    "dx, dw, db = affine_relu_backward(dout, cache)\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(lambda x: affine_relu_forward(x, w, b)[0], x, dout)\n",
    "dw_num = eval_numerical_gradient_array(lambda w: affine_relu_forward(x, w, b)[0], w, dout)\n",
    "db_num = eval_numerical_gradient_array(lambda b: affine_relu_forward(x, w, b)[0], b, dout)\n",
    "\n",
    "# Relative error should be around e-10 or less\n",
    "print('Testing affine_relu_forward and affine_relu_backward:')\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "print('dw error: ', rel_error(dw_num, dw))\n",
    "print('db error: ', rel_error(db_num, db))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loss layers: Softmax and SVM\n",
    "You implemented these loss functions in the last assignment, so we'll give them to you for free here. \n",
    "\n",
    "You should still make sure you understand how they work by looking at the implementations in `cs231n/layers.py`.\n",
    "\n",
    "You can make sure that the implementations are correct by running the following:\n",
    "\n",
    "你在上次作业中实现了这些损失函数，所以我们会在这里免费给你。\n",
    "\n",
    "您仍然应该通过查看`cs231n/layers.py`中的实现来确保理解它们是如何工作的。\n",
    "\n",
    "你可以通过运行以下程序来确保实现是正确的:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing svm_loss:\n",
      "loss:  8.999602749096233\n",
      "dx error:  1.4021566006651672e-09\n",
      "\n",
      "Testing softmax_loss:\n",
      "loss:  2.302545844500738\n",
      "dx error:  9.384673161989355e-09\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "num_classes, num_inputs = 10, 50\n",
    "x = 0.001 * np.random.randn(num_inputs, num_classes)\n",
    "y = np.random.randint(num_classes, size=num_inputs)\n",
    "\n",
    "dx_num = eval_numerical_gradient(lambda x: svm_loss(x, y)[0], x, verbose=False)\n",
    "loss, dx = svm_loss(x, y)\n",
    "\n",
    "# Test svm_loss function. Loss should be around 9 and dx error should be around the order of e-9\n",
    "print('Testing svm_loss:')\n",
    "print('loss: ', loss)\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "\n",
    "dx_num = eval_numerical_gradient(lambda x: softmax_loss(x, y)[0], x, verbose=False)\n",
    "loss, dx = softmax_loss(x, y)\n",
    "\n",
    "# Test softmax_loss function. Loss should be close to 2.3 and dx error should be around e-8\n",
    "print('\\nTesting softmax_loss:')\n",
    "print('loss: ', loss)\n",
    "print('dx error: ', rel_error(dx_num, dx))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Two-layer network\n",
    "In the previous assignment you implemented a two-layer neural network in a single monolithic class. \n",
    "\n",
    "Now that you have implemented modular versions of the necessary layers, you will reimplement the two layer network using these modular implementations.\n",
    "\n",
    "Open the file `cs231n/classifiers/fc_net.py` and complete the implementation of the `TwoLayerNet` class. \n",
    "\n",
    "This class will serve as a model for the other networks you will implement in this assignment, so read through it to make sure you understand the API. \n",
    "\n",
    "You can run the cell below to test your implementation.\n",
    "\n",
    "在之前的作业中，您在一个monolithic类中实现了一个两层神经网络。\n",
    "\n",
    "现在您已经实现了必要层的模块版本，您将使用这些模块实现重新实现这两层网络。\n",
    "\n",
    "打开文件`cs231n/classifiers/fc_net.py`并完成`TwoLayerNet`类的实现。\n",
    "\n",
    "这个类将作为在这个作业中要实现的其他网络的模型，所以请通读它以确保您理解了这个API。\n",
    "\n",
    "您可以运行下面的单元来测试您的实现。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing initialization ... \n",
      "Testing test-time forward pass ... \n",
      "Testing training loss (no regularization)\n",
      "Running numeric gradient check with reg =  0.0\n",
      "W1 relative error: 1.52e-08\n",
      "W2 relative error: 3.48e-10\n",
      "b1 relative error: 6.55e-09\n",
      "b2 relative error: 4.33e-10\n",
      "Running numeric gradient check with reg =  0.7\n",
      "W1 relative error: 8.18e-07\n",
      "W2 relative error: 2.85e-08\n",
      "b1 relative error: 1.09e-09\n",
      "b2 relative error: 7.76e-10\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "N, D, H, C = 3, 5, 50, 7\n",
    "X = np.random.randn(N, D)\n",
    "y = np.random.randint(C, size=N)\n",
    "\n",
    "std = 1e-3\n",
    "model = TwoLayerNet(input_dim=D, hidden_dim=H, num_classes=C, weight_scale=std)\n",
    "\n",
    "print('Testing initialization ... ')\n",
    "W1_std = abs(model.params['W1'].std() - std)\n",
    "b1 = model.params['b1']\n",
    "W2_std = abs(model.params['W2'].std() - std)\n",
    "b2 = model.params['b2']\n",
    "assert W1_std < std / 10, 'First layer weights do not seem right'\n",
    "assert np.all(b1 == 0), 'First layer biases do not seem right'\n",
    "assert W2_std < std / 10, 'Second layer weights do not seem right'\n",
    "assert np.all(b2 == 0), 'Second layer biases do not seem right'\n",
    "\n",
    "print('Testing test-time forward pass ... ')\n",
    "model.params['W1'] = np.linspace(-0.7, 0.3, num=D*H).reshape(D, H)\n",
    "model.params['b1'] = np.linspace(-0.1, 0.9, num=H)\n",
    "model.params['W2'] = np.linspace(-0.3, 0.4, num=H*C).reshape(H, C)\n",
    "model.params['b2'] = np.linspace(-0.9, 0.1, num=C)\n",
    "X = np.linspace(-5.5, 4.5, num=N*D).reshape(D, N).T\n",
    "scores = model.loss(X)\n",
    "correct_scores = np.asarray(\n",
    "  [[11.53165108,  12.2917344,   13.05181771,  13.81190102,  14.57198434, 15.33206765,  16.09215096],\n",
    "   [12.05769098,  12.74614105,  13.43459113,  14.1230412,   14.81149128, 15.49994135,  16.18839143],\n",
    "   [12.58373087,  13.20054771,  13.81736455,  14.43418138,  15.05099822, 15.66781506,  16.2846319 ]])\n",
    "scores_diff = np.abs(scores - correct_scores).sum()\n",
    "assert scores_diff < 1e-6, 'Problem with test-time forward pass'\n",
    "\n",
    "print('Testing training loss (no regularization)')\n",
    "y = np.asarray([0, 5, 1])\n",
    "loss, grads = model.loss(X, y)\n",
    "correct_loss = 3.4702243556\n",
    "assert abs(loss - correct_loss) < 1e-10, 'Problem with training-time loss'\n",
    "\n",
    "model.reg = 1.0\n",
    "loss, grads = model.loss(X, y)\n",
    "correct_loss = 26.5948426952\n",
    "assert abs(loss - correct_loss) < 1e-10, 'Problem with regularization loss'\n",
    "\n",
    "# Errors should be around e-7 or less\n",
    "for reg in [0.0, 0.7]:\n",
    "  print('Running numeric gradient check with reg = ', reg)\n",
    "  model.reg = reg\n",
    "  loss, grads = model.loss(X, y)\n",
    "\n",
    "  for name in sorted(grads):\n",
    "    f = lambda _: model.loss(X, y)[0]\n",
    "    grad_num = eval_numerical_gradient(f, model.params[name], verbose=False)\n",
    "    print('%s relative error: %.2e' % (name, rel_error(grad_num, grads[name])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Solver\n",
    "In the previous assignment, the logic for training models was coupled to the models themselves. \n",
    "\n",
    "Following a more modular design, for this assignment we have split the logic for training models into a separate class.\n",
    "\n",
    "Open the file `cs231n/solver.py` and read through it to familiarize yourself with the API. \n",
    "\n",
    "After doing so, use a `Solver` instance to train a `TwoLayerNet` that achieves at least `50%` accuracy on the validation set.\n",
    "\n",
    "在之前的作业中，训练模型的逻辑与模型本身是耦合的。\n",
    "\n",
    "按照更加模块化的设计，在这次作业中，我们将训练模型的逻辑划分为单独的类。\n",
    "\n",
    "打开文件`cs231n/solver.py`，然后通读一遍以熟悉API。\n",
    "\n",
    "这样做之后，使用一个`Solver`实例来训练一个`TwoLayerNet`，它在验证集上达到至少`50%`的精度。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 4900) loss: 2.319743\n",
      "(Epoch 0 / 10) train acc: 0.132000; val_acc: 0.130000\n",
      "(Iteration 101 / 4900) loss: 1.877247\n",
      "(Iteration 201 / 4900) loss: 1.771366\n",
      "(Iteration 301 / 4900) loss: 1.892875\n",
      "(Iteration 401 / 4900) loss: 1.473872\n",
      "(Epoch 1 / 10) train acc: 0.438000; val_acc: 0.444000\n",
      "(Iteration 501 / 4900) loss: 1.643228\n",
      "(Iteration 601 / 4900) loss: 1.534770\n",
      "(Iteration 701 / 4900) loss: 1.453180\n",
      "(Iteration 801 / 4900) loss: 1.420600\n",
      "(Iteration 901 / 4900) loss: 1.452053\n",
      "(Epoch 2 / 10) train acc: 0.496000; val_acc: 0.474000\n",
      "(Iteration 1001 / 4900) loss: 1.433990\n",
      "(Iteration 1101 / 4900) loss: 1.571651\n",
      "(Iteration 1201 / 4900) loss: 1.178906\n",
      "(Iteration 1301 / 4900) loss: 1.213324\n",
      "(Iteration 1401 / 4900) loss: 1.215125\n",
      "(Epoch 3 / 10) train acc: 0.542000; val_acc: 0.479000\n",
      "(Iteration 1501 / 4900) loss: 1.358257\n",
      "(Iteration 1601 / 4900) loss: 1.250071\n",
      "(Iteration 1701 / 4900) loss: 1.367561\n",
      "(Iteration 1801 / 4900) loss: 1.194384\n",
      "(Iteration 1901 / 4900) loss: 1.328785\n",
      "(Epoch 4 / 10) train acc: 0.555000; val_acc: 0.498000\n",
      "(Iteration 2001 / 4900) loss: 1.472518\n",
      "(Iteration 2101 / 4900) loss: 1.344496\n",
      "(Iteration 2201 / 4900) loss: 1.446809\n",
      "(Iteration 2301 / 4900) loss: 1.275537\n",
      "(Iteration 2401 / 4900) loss: 1.312315\n",
      "(Epoch 5 / 10) train acc: 0.608000; val_acc: 0.487000\n",
      "(Iteration 2501 / 4900) loss: 1.233777\n",
      "(Iteration 2601 / 4900) loss: 1.568667\n",
      "(Iteration 2701 / 4900) loss: 1.131592\n",
      "(Iteration 2801 / 4900) loss: 1.269777\n",
      "(Iteration 2901 / 4900) loss: 1.406804\n",
      "(Epoch 6 / 10) train acc: 0.567000; val_acc: 0.537000\n",
      "(Iteration 3001 / 4900) loss: 1.472330\n",
      "(Iteration 3101 / 4900) loss: 1.185231\n",
      "(Iteration 3201 / 4900) loss: 1.282078\n",
      "(Iteration 3301 / 4900) loss: 1.190159\n",
      "(Iteration 3401 / 4900) loss: 1.324238\n",
      "(Epoch 7 / 10) train acc: 0.602000; val_acc: 0.518000\n",
      "(Iteration 3501 / 4900) loss: 1.212934\n",
      "(Iteration 3601 / 4900) loss: 1.052943\n",
      "(Iteration 3701 / 4900) loss: 1.062214\n",
      "(Iteration 3801 / 4900) loss: 1.071836\n",
      "(Iteration 3901 / 4900) loss: 1.333768\n",
      "(Epoch 8 / 10) train acc: 0.588000; val_acc: 0.531000\n",
      "(Iteration 4001 / 4900) loss: 1.249703\n",
      "(Iteration 4101 / 4900) loss: 1.255340\n",
      "(Iteration 4201 / 4900) loss: 1.149953\n",
      "(Iteration 4301 / 4900) loss: 1.261829\n",
      "(Iteration 4401 / 4900) loss: 1.207234\n",
      "(Epoch 9 / 10) train acc: 0.618000; val_acc: 0.536000\n",
      "(Iteration 4501 / 4900) loss: 1.222363\n",
      "(Iteration 4601 / 4900) loss: 1.381008\n",
      "(Iteration 4701 / 4900) loss: 1.290772\n",
      "(Iteration 4801 / 4900) loss: 1.140604\n",
      "(Epoch 10 / 10) train acc: 0.621000; val_acc: 0.523000\n",
      "test acc: 0.524000\n"
     ]
    }
   ],
   "source": [
    "# model = TwoLayerNet()\n",
    "model = TwoLayerNet(reg=1e-1)\n",
    "solver = None\n",
    "\n",
    "##############################################################################\n",
    "# TODO: Use a Solver instance to train a TwoLayerNet that achieves at least  #\n",
    "# 50% accuracy on the validation set.                                        #\n",
    "##############################################################################\n",
    "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "# 使用一个求解器实例来训练一个TwoLayerNet，在验证集上获得至少50%的准确性。\n",
    "pass\n",
    "\n",
    "solver = Solver(model, data,\n",
    "                update_rule='sgd',\n",
    "                optim_config={\n",
    "                'learning_rate': 1e-3,\n",
    "                },\n",
    "                lr_decay=0.8,\n",
    "                num_epochs=10, batch_size=100,\n",
    "                print_every=100)\n",
    "solver.train()\n",
    "\n",
    "scores = model.loss(data['X_test'])\n",
    "y_pred = np.argmax(scores, axis = 1)\n",
    "acc = np.mean(y_pred == data['y_test'])\n",
    "print('test acc: %f' %(acc))\n",
    "\n",
    "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "##############################################################################\n",
    "#                             END OF YOUR CODE                               #\n",
    "##############################################################################"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x864 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Run this cell to visualize training loss and train / val accuracy\n",
    "\n",
    "plt.subplot(2, 1, 1)\n",
    "plt.title('Training loss')\n",
    "plt.plot(solver.loss_history, 'o')\n",
    "plt.xlabel('Iteration')\n",
    "\n",
    "plt.subplot(2, 1, 2)\n",
    "plt.title('Accuracy')\n",
    "plt.plot(solver.train_acc_history, '-o', label='train')\n",
    "plt.plot(solver.val_acc_history, '-o', label='val')\n",
    "plt.plot([0.5] * len(solver.val_acc_history), 'k--')\n",
    "plt.xlabel('Epoch')\n",
    "plt.legend(loc='lower right')\n",
    "plt.gcf().set_size_inches(15, 12)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Multilayer network\n",
    "Next you will implement a fully-connected network with an arbitrary number of hidden layers.\n",
    "\n",
    "Read through the `FullyConnectedNet` class in the file `cs231n/classifiers/fc_net.py`.\n",
    "\n",
    "Implement the initialization, the forward pass, and the backward pass. \n",
    "\n",
    "For the moment don't worry about implementing dropout or batch/layer normalization; \n",
    "\n",
    "we will add those features soon.\n",
    "\n",
    "接下来，您将实现一个具有任意数量隐藏层的全连接网络。\n",
    "\n",
    "读取文件`cs231n/classifiers/fc_net.py`中的`FullyConnectedNet`类。\n",
    "\n",
    "实现初始化、前向传播和反向传播。\n",
    "\n",
    "目前，不必担心实现dropout或batch/layer normalization;\n",
    "\n",
    "我们将很快添加这些功能。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initial loss and gradient check\n",
    "\n",
    "As a sanity check, run the following to check the initial loss and to gradient check the network both with and without regularization. Do the initial losses seem reasonable?\n",
    "\n",
    "For gradient checking, you should expect to see errors around 1e-7 or less.\n",
    "\n",
    "作为一种完整性检查，运行以下命令来检查初始损失，并对有正则化和无正则化的网络进行梯度检查。最初的损失合理吗?\n",
    "\n",
    "对于梯度检查，您应该期望看到错误大概是1e-7或更少。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running check with reg =  0\n",
      "Initial loss:  2.2611955101340957\n",
      "W1 relative error: 1.10e-04\n",
      "W2 relative error: 2.85e-06\n",
      "W3 relative error: 3.92e-10\n",
      "b1 relative error: 4.44e-08\n",
      "b2 relative error: 2.22e-08\n",
      "b3 relative error: 4.78e-11\n",
      "beta1 relative error: 7.33e-09\n",
      "beta2 relative error: 1.89e-09\n",
      "gamma1 relative error: 7.57e-09\n",
      "gamma2 relative error: 1.96e-09\n",
      "Running check with reg =  3.14\n",
      "Initial loss:  6.996533220108303\n",
      "W1 relative error: 1.98e-06\n",
      "W2 relative error: 2.28e-06\n",
      "W3 relative error: 1.11e-08\n",
      "b1 relative error: 5.55e-09\n",
      "b2 relative error: 5.55e-09\n",
      "b3 relative error: 2.23e-10\n",
      "beta1 relative error: 6.65e-09\n",
      "beta2 relative error: 3.48e-09\n",
      "gamma1 relative error: 5.94e-09\n",
      "gamma2 relative error: 4.14e-09\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "N, D, H1, H2, C = 2, 15, 20, 30, 10\n",
    "X = np.random.randn(N, D)\n",
    "y = np.random.randint(C, size=(N,))\n",
    "\n",
    "for reg in [0, 3.14]:\n",
    "    print('Running check with reg = ', reg)\n",
    "    model = FullyConnectedNet([H1, H2], input_dim=D, num_classes=C,\n",
    "           normalization ='batchnorm', reg=reg, weight_scale=5e-2, dtype=np.float64)\n",
    "\n",
    "    loss, grads = model.loss(X, y)\n",
    "    print('Initial loss: ', loss)\n",
    "\n",
    "    # Most of the errors should be on the order of e-7 or smaller.   \n",
    "    # NOTE: It is fine however to see an error for W2 on the order of e-5\n",
    "    # for the check when reg = 0.0\n",
    "    # 大多数误差应该在e-7或更小的数量级。\n",
    "    # 注意:当reg = 0.0时，\n",
    "    for name in sorted(grads):\n",
    "        f = lambda _: model.loss(X, y)[0]\n",
    "        grad_num = eval_numerical_gradient(f, model.params[name], verbose=False, h=1e-5)\n",
    "        print('%s relative error: %.2e' % (name, rel_error(grad_num, grads[name])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As another sanity check, make sure you can overfit a small dataset of 50 images. \n",
    "\n",
    "First we will try a three-layer network with 100 units in each hidden layer. \n",
    "\n",
    "In the following cell, tweak the **learning rate** and **weight initialization scale** to overfit and achieve 100% training accuracy within 20 epochs.\n",
    "\n",
    "作为另一个完整性检查，请确保您可以过拟合50个图像的小数据集。\n",
    "\n",
    "首先，我们将尝试一个三层网络，每个隐藏层有100个单位。\n",
    "\n",
    "在下面的cell中，将**学习率**和**权值初始化scale**调整为overfit，在 20 epochs 内达到100%的训练精度。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 40) loss: 2.363364\n",
      "(Epoch 0 / 20) train acc: 0.200000; val_acc: 0.100000\n",
      "(Epoch 1 / 20) train acc: 0.300000; val_acc: 0.123000\n",
      "(Epoch 2 / 20) train acc: 0.420000; val_acc: 0.164000\n",
      "(Epoch 3 / 20) train acc: 0.480000; val_acc: 0.182000\n",
      "(Epoch 4 / 20) train acc: 0.480000; val_acc: 0.180000\n",
      "(Epoch 5 / 20) train acc: 0.680000; val_acc: 0.183000\n",
      "(Iteration 11 / 40) loss: 1.012326\n",
      "(Epoch 6 / 20) train acc: 0.740000; val_acc: 0.195000\n",
      "(Epoch 7 / 20) train acc: 0.700000; val_acc: 0.187000\n",
      "(Epoch 8 / 20) train acc: 0.780000; val_acc: 0.185000\n",
      "(Epoch 9 / 20) train acc: 0.860000; val_acc: 0.201000\n",
      "(Epoch 10 / 20) train acc: 0.880000; val_acc: 0.196000\n",
      "(Iteration 21 / 40) loss: 0.499348\n",
      "(Epoch 11 / 20) train acc: 0.920000; val_acc: 0.199000\n",
      "(Epoch 12 / 20) train acc: 0.900000; val_acc: 0.187000\n",
      "(Epoch 13 / 20) train acc: 0.940000; val_acc: 0.204000\n",
      "(Epoch 14 / 20) train acc: 1.000000; val_acc: 0.199000\n",
      "(Epoch 15 / 20) train acc: 0.960000; val_acc: 0.193000\n",
      "(Iteration 31 / 40) loss: 0.209285\n",
      "(Epoch 16 / 20) train acc: 1.000000; val_acc: 0.195000\n",
      "(Epoch 17 / 20) train acc: 1.000000; val_acc: 0.214000\n",
      "(Epoch 18 / 20) train acc: 1.000000; val_acc: 0.213000\n",
      "(Epoch 19 / 20) train acc: 1.000000; val_acc: 0.197000\n",
      "(Epoch 20 / 20) train acc: 1.000000; val_acc: 0.198000\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmQAAAHwCAYAAAAIDnN0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzt3X2UpVddJ/rvz04DNYKUkjjaFTCosXkxSkOLeIMOopcGVOjJ6AIcBB29Aa+MOnKLSbsUHa7eRHuEGR0uIyqCw6sL2zYqTKsERZjhpUMHmgz2nfCipDpAEDuA1ECn2fePOpVUN1XVVdV1zq465/NZq1ads89zTv3qybMq3957P3tXay0AAPTzJb0LAACYdAIZAEBnAhkAQGcCGQBAZwIZAEBnAhkAQGcCGTB0VbWjqj5TVQ/YzGM3UMcvVdXLN/tzV/hZ311VH17l9d+uqp8dRS3A1ndR7wKAraeqPrPk6T9J8rkkZwbPn9Vae9V6Pq+1dibJvTf72O2stfZjazmuqm5N8vTW2l8OtyKgJ4EM+CKttbsC0aCX58daa3+x0vFVdVFr7c5R1Mba+e8C24chS2DdBkN/r6uq11TVp5M8vaq+rareXlWnquq2qvr1qto5OP6iqmpVddng+SsHr7+xqj5dVf+9qh643mMHrz+hqv6/qrqjqn6jqt5WVT+8xt9jf1XdPKj5hqraveS1n62qk1X1qar6m6p6zKD9UVX17kH7x6rq4Hl+xvOq6vbBZz1jSfsrq+oXB4+/sqreMKjjk1X1lkH7a5LsSvLGwTDuz6yh7luraraqjif5bFUdqKrXnVPTS6rq36/lHAGjIZABG/XPk7w6yX2TvC7JnUl+KsnFSa5M8vgkz1rl/T+Y5OeTfEWSv0vyf6/32Kr6yiS/n2R28HM/lOSRaym+qh6c5JVJ/nWSS5L8RZI/rqqdVfXQQe0Pb619WZInDH5ukvxGkoOD9q9P8vpVfsylSaayEKqeneQlVfVlyxw3m+SDgzq+avC7prX2tCQnkzyhtXbv1toLV6t7yec9dVDzfZP8lyTfs/hzq+oeSX5g0A5sEQIZsFFvba39cWvtC621+dbau1pr72it3dla+2CSlyb5Z6u8//WttaOttdNJXpXkYRs49nuT3NRa+6PBay9K8ok11v/UJNe31m4YvPe6JF+W5FuzEC7vleShg2G/Dw1+pyQ5neTyqrpfa+3TrbV3rPIz/leSX2qtnW6tXZ+FuXjfsMxxp7MQ2h7QWvt8a+2vNlj3ov/YWrt18N/l1iT/Pcm/GLz2xCQnW2vvWeVnACMmkAEb9ZGlT6rqQVX1p1X10ar6VJIXZKHXaiUfXfL4s1l9Iv9Kx+5aWkdrrSW5dQ21L773b5e89wuD98601k4keW4WfoePD4Zmv2pw6I8keUiSE1X1zqp64io/4xODmxSWq32p6wa1vKmqPlBVsxupe8kxHznnPa9I8vTB46dH7xhsOQIZsFHtnOe/meR9Sb5+MJz3/CQ15Bpuy8KwYJKkqipnB5PVnEzyNUve+yWDz5pLktbaK1trVyZ5YJIdSa4dtJ9orT01yVcm+bUkf1BV97qQX6K19qnW2r9prV2WZH+Sf1tVi72L557nVete4T2HkjxiMBT7hCwMNQNbiEAGbJb7JLkjyT8O5jmtNn9ss/xJkodX1fdV1UVZmMN2yRrf+/tJnlRVjxnMv5pN8ukk76iqB1fVd1bVPZPMD77OJElV/VBVXTzombojC+HnCxfySwzq/7pBoLxj8LMWe9Y+luRr11L3Sp/fWvtskj9M8pokb2utza10LNCHQAZslucmeWYWwsFvZmGi/1C11j6W5ClJXpjk75N8XZJjWZirdb733pyFel+S5PYs3ITwpMG8rHsm+dUszEf7aJIvT/Jzg7c+Mcn7B3eX/vskT2mtff4Cf5XdSW5I8pkkb8vCHLC3Dl77f5L8u8EdlT99nrpX84okV8RwJWxJtTDlAmD7q6odWRjS+/7W2l/3rmcrqaqvTfLeJF/VWvvM+Y4HRksPGbCtVdXjq+q+g+HFn8/CHZLv7FzWljKYZ/YzSV4tjMHWZKV+YLt7dBaWwrhHkpuT7G+tnXfIclJU1X2zMOH/w0n29a0GWIkhSwCAzgxZAgB0JpABAHS27eaQXXzxxe2yyy7rXQYAwHndeOONn2itnXd9xG0XyC677LIcPXq0dxkAAOdVVX97/qMMWQIAdCeQAQB0JpABAHQmkAEAdCaQAQB0JpABAHQmkAEAdCaQAQB0JpABAHQmkAEAdCaQAQB0JpABAHQmkAEAdCaQAQB0JpABAHR2Ue8CtprDx+Zy8MiJnDw1n13TU5ndtzv798z0LgsAGGMC2RKHj83lwKHjmT99Jkkyd2o+Bw4dTxKhDAAYGkOWSxw8cuKuMLZo/vSZHDxyolNFAMAkEMiWOHlqfl3tAACbQSBbYtf01LraAQA2g0C2xOy+3ZnaueOstqmdOzK7b3enigCASWBS/xKLE/fdZQkAjJJAdo79e2YEMABgpAxZAgB0JpABAHQmkAEAdCaQAQB0JpABAHQmkAEAdCaQAQB0JpABAHQmkAEAdCaQAQB0JpABAHQmkAEAdCaQAQB0dlHvAsbB4WNzOXjkRE6ems+u6anM7tud/XtmepcFAGwTAtkFOnxsLgcOHc/86TNJkrlT8zlw6HiSCGUAwJoYsrxAB4+cuCuMLZo/fSYHj5zoVBEAsN0IZBfo5Kn5dbUDAJxLILtAu6an1tUOAHAugewCze7bnamdO85qm9q5I7P7dneqCADYbkzqv0CLE/fdZQkAbJRAtgn275kRwACADTNkCQDQmUAGANCZQAYA0JlABgDQmUAGANCZQAYA0JlABgDQmUAGANCZQAYA0JlABgDQmUAGANCZQAYA0JlABgDQmUAGANCZQAYA0JlABgDQmUAGANCZQAYA0JlABgDQmUAGANCZQAYA0NlFvQuYVIePzeXgkRM5eWo+u6anMrtvd/bvmeldFgDQgUDWweFjczlw6HjmT59Jksydms+BQ8eTRCgDgAlkyLKDg0dO3BXGFs2fPpODR050qggA6Ekg6+Dkqfl1tQMA400g62DX9NS62gGA8SaQdTC7b3emdu44q21q547M7tvdqSIAoCeT+jtYnLjvLksAIBHIutm/Z0YAAwCSGLIEAOhOIAMA6EwgAwDobGiBrKruX1Vvrqr3V9XNVfVTyxxTVfXrVXVLVb23qh4+rHoAALaqYU7qvzPJc1tr766q+yS5sar+vLX2P5Yc84Qklw++vjXJSwbfAQAmxtACWWvttiS3DR5/uqren2QmydJA9uQkv9daa0neXlXTVfXVg/dyDhuSA8B4GsmyF1V1WZI9Sd5xzkszST6y5PmtgzaB7Bw2JAeA8TX0Sf1Vde8kf5Dkp1trnzr35WXe0pb5jKur6mhVHb399tuHUeaWZ0NyABhfQw1kVbUzC2HsVa21Q8sccmuS+y95fmmSk+ce1Fp7aWttb2tt7yWXXDKcYrc4G5IDwPga5l2WleR3kry/tfbCFQ67PskzBndbPirJHeaPLc+G5AAwvobZQ3Zlkh9K8tiqumnw9cSqenZVPXtwzBuSfDDJLUl+K8n/OcR6tjUbkgPA+BrmXZZvzfJzxJYe05L8xLBqGCc2JAeA8WVz8W3EhuQAMJ4EsjFn7TIA2PoEsjFm7TIA2B5sLj7GrF0GANuDQDbGrF0GANuDQDbGrF0GANuDQDbGrF0GANuDSf1jzNplALA9CGRjztplALD1GbIEAOhMIAMA6EwgAwDoTCADAOhMIAMA6EwgAwDoTCADAOhMIAMA6EwgAwDozEr9fJHDx+ZstwQAIySQcZbDx+Zy4NDxzJ8+kySZOzWfA4eOJ4lQBgBDYsiSsxw8cuKuMLZo/vSZHDxyolNFADD+BDLOcvLU/LraAYALJ5Bxll3TU+tqBwAunEDGWWb37c7Uzh1ntU3t3JHZfbs7VQQA48+kfs6yOHHfXZYAMDoCGV9k/54ZAQwARsiQJQBAZwIZAEBnAhkAQGcCGQBAZwIZAEBnAhkAQGcCGQBAZwIZAEBnAhkAQGcCGQBAZwIZAEBnAhkAQGcCGQBAZwIZAEBnAhkAQGcCGQBAZxf1LgCG7fCxuRw8ciInT81n1/RUZvftzv49M73LAoC7CGSMtcPH5nLg0PHMnz6TJJk7NZ8Dh44niVAGwJZhyJKxdvDIibvC2KL502dy8MiJThUBwBcTyBhrJ0/Nr6sdAHoQyBhru6an1tUOAD0IZIy12X27M7Vzx1ltUzt3ZHbf7k4VAcAXM6mfsbY4cd9dlgBsZQIZY2//nhkBDIAtzZAlAEBnAhkAQGcCGQBAZwIZAEBnAhkAQGcCGQBAZwIZAEBnAhkAQGcCGQBAZwIZAEBnAhkAQGcCGQBAZwIZAEBnAhkAQGcCGQBAZwIZAEBnAhkAQGcCGQBAZwIZAEBnAhkAQGcCGQBAZwIZAEBnAhkAQGcCGQBAZxf1LoDxcPjYXA4eOZGTp+aza3oqs/t2Z/+emd5lAcC2IJBxwQ4fm8uBQ8czf/pMkmTu1HwOHDqeJEIZAKzB0IYsq+plVfXxqnrfCq8/pqruqKqbBl/PH1YtDNfBIyfuCmOL5k+fycEjJzpVBADbyzB7yF6e5D8l+b1Vjvnr1tr3DrEGRuDkqfl1tQMAZxtaD1lr7S1JPjmsz2fr2DU9ta52AOBsve+y/Laqek9VvbGqHtq5FjZodt/uTO3ccVbb1M4dmd23u1NFALC99JzU/+4kX9Na+0xVPTHJ4SSXL3dgVV2d5OokecADHjC6ClmTxYn77rIEgI2p1trwPrzqsiR/0lr7xjUc++Eke1trn1jtuL1797ajR49uSn0AAMNUVTe21vae77huQ5ZV9VVVVYPHjxzU8ve96gEA6GVoQ5ZV9Zokj0lycVXdmuQXkuxMktbaf07y/Ul+vKruTDKf5KltmN11AABb1NACWWvtaed5/T9lYVkMJpTV/QFggZX66cLq/gBwt97LXjChrO4PAHcTyOjC6v4AcDeBjC6s7g8AdxPI6MLq/gBwN5P66cLq/gBwN4GMbvbvmRHAACCGLAEAuhPIAAA6E8gAADoTyAAAOjOpn23F/pcAjCOBjG3D/pcAjCtDlmwb9r8EYFytK5DVgi8dVjGwGvtfAjCuzhvIqur3qurLquqfJLk5yYeq6meGXxqczf6XAIyrtfSQXdFa+1SS/Un+LMmlSX54mEXBcux/CcC4Wsuk/ntU1UVJnpzkJa21z1fVF4ZcF3wR+18CMK7WEsh+O8nfJXlfkr+qqgck+cxQq4IV2P8SgHF03iHL1tqLWmu7WmuPa621JB9J8tjhlwYAMBnWMqn/OVX1ZYPHv5nkHUm+fdiFAQBMirVM6r+6tfapqnpckpkkP57kV4dbFgDA5FhLIGuD709I8ruttRvX+D4AANZgLcHqPVX1hiTfl+SNVXXv3B3SAAC4QGu5y/JHkjwiyS2ttc9W1cVJfnS4ZQEATI7zBrLW2plBCLuqqpLkr1prbxx6ZQAAE2Itd1n+cpLnJfng4Gu2qn5p2IUBAEyKtQxZfl+Sh7fW7kySqnpZkncn+blhFgYAMCnWerfkfVZ4DADABVpLD9mvJnl3Vb0pSSV5TJLnD7MoAIBJspZJ/a+sqjcn+dYsBLLnt9bmhl4ZAMCEWDGQVdU3ndN0y+D7/arqfq219w6vLACAybFaD9mLV3mtJfmOTa4FAGAirRjIWms2EAcAGAF7UgIAdCaQAQB0JpABAHR23mUvlrnbMknuSPKR1toXNr8kAIDJspaFYX8nycOS3JyFdcgenOR9Se5bVVe31t40xPoAAMbeWoYs/2eSR7TWHtZa++Ykj0hyU5J9SX5tmMUBAEyCtQSyBy9dBLa1djwLm43fssp7AABYo7UMWX6gqn4jyWsHz5+S5JaqumeSO4dWGQDAhFhLD9kzktya5JokB5KcTPLMLISx7xpeaQAAk2Etm4t/NsmvDL7OdcemVwQAMGHWsuzFo5L8QpKvWXp8a+0bhlgXAMDEWMscst9N8rwkNyY5M9xyAAAmz1oC2adaa3889EoAACbUWgLZDVV1bZJDST632Lh0KQwAADZuLYHs0ed8T5KW5Ds2vxwAgMmzlrssv30UhQAATKoVA1lVPa219pqq+snlXm+t/frwygIAmByr9ZB9+eD7JaMoBABgUq0YyFpr/+/g+8+PrhwAgMmzloVhL07yr5JclrMXhr16eGUBAEyOtdxl+UdJ3p7krbEwLHR3+NhcDh45kZOn5rNreiqz+3Zn/56Z3mUBcAHWEsi+tLX23KFXApzX4WNzOXDoeOZPL/zbaO7UfA4cOp4kQhnANvYlazjmjVX1uKFXApzXwSMn7gpji+ZPn8nBIyc6VQTAZlhLIHt2kv9aVZ+pqk9W1T9U1SeHXRjwxU6eml9XOwDbw1qGLC8eehXAmuyansrcMuFr1/RUh2oA2Cwr9pBV1eWDhw9d4QsYsdl9uzO1c8dZbVM7d2R23+5OFQGwGVbrIbsmyY8mefEyr9nLEjpYnLjvLkuA8VKttd41rMvevXvb0aNHe5cB24qlMgD6qKobW2t7z3fcWuaQpaoelOQhSe612NZae/XGywNGZZRLZQh+ABuzlpX6fy7J45I8KMmRJPuysEisQAbbwGpLZawWltYbrqyRBrBxa1n24ilJvjPJba21H0ryzVljzxrQ30aWylgMV3On5tNyd7g6fGxuxfdYIw1g49YSyOZba2eS3FlV90ny0SRfO9yygM2y0pIYqy2VsZFwZY00gI1bSyA7VlXTSV6W5GiSdyZ591CrAjbNRpbK2Ei42kjwA2DBqoGsqirJL7bWTrXWXpzke5I8q7X2jJFUB1yw/Xtmcu1VV2RmeiqVZGZ6KtdedcWq87o2Eq6skQawcavOBWuttar6kySPGDy/ZSRVAZtq/56ZdU2sn923+6wJ+sn5w5U10gA2bi2T899ZVQ9vrRmmhAmx0XC13uAHwIIVA1lVXdRauzPJo5P8H1X1gST/mKSy0Hn28BHVCHQgXAGMzmo9ZO9M8vAk+0dUCwDARFotkFWStNY+MKJaAAAm0mqB7JKq+pmVXmytvXAI9QAATJzVAtmOJPfOoKcMAIDhWC2Q3dZae8HIKgEAmFDnnUMGk2i9G2sDwIVYbaX+77qQD66ql1XVx6vqfSu8XlX161V1S1W9t6oso8GWsJGNtQHgQqwYyFprn7zAz355ksev8voTklw++Lo6yUsu8OfBptjIxtoAcCHWsrn4hrTW3pJktVD35CS/1xa8Pcl0VX31sOqBtdrIxtoAcCGGFsjWYCbJR5Y8v3XQBl1tZGNtALgQPQPZcjcNtGUPrLq6qo5W1dHbb799yGUx6Wb37c7Uzh1ntZ1vY20AuBA9A9mtSe6/5PmlSU4ud2Br7aWttb2ttb2XXHLJSIpjcu3fM5Nrr7oiM9NTqSQz01O59qor3GUJwNCstuzFsF2f5DlV9dok35rkjtbabR3rgbvYWBuAURpaIKuq1yR5TJKLq+rWJL+QZGeStNb+c5I3JHlikluSfDbJjwyrFgCArWxogay19rTzvN6S/MSwfj4AwHbRcw4ZAAARyAAAuhPIAAA663mXJUw8m5gDkAhk0M3iJuaL+2YubmKeRCgDmDCGLKETm5gDsEggg05sYg7AIoEMOrGJOQCLBDLoxCbmACwyqR86WZy47y5LAAQy6Mgm5gAkhiwBALoTyAAAOhPIAAA6M4cMNoltkADYKIEMNoFtkAC4EIYsYRPYBgmACyGQwSawDRIAF0Igg01gGyQALoRABpvANkgAXAiT+mET2AYJgAshkMEmsQ0SABtlyBIAoDOBDACgM4EMAKAzgQwAoDOBDACgM4EMAKAzgQwAoDOBDACgM4EMAKAzgQwAoDOBDACgM4EMAKAzgQwAoDOBDACgM4EMAKAzgQwAoDOBDACgM4EMAKAzgQwAoDOBDACgs4t6FwBMtsPH5nLwyImcPDWfXdNTmd23O/v3zPQuC2CkBDKgm8PH5nLg0PHMnz6TJJk7NZ8Dh44niVAGTBRDlkA3B4+cuCuMLZo/fSYHj5zoVBFAHwIZ0M3JU/PragcYV4YsgW52TU9lbpnwtWt6qkM124u5dzBe9JAB3czu252pnTvOapvauSOz+3Z3qmh7WJx7N3dqPi13z707fGyud2nABglkQDf798zk2quuyMz0VCrJzPRUrr3qCj0952HuHYwfQ5ZAV/v3zAhg62TuHYwfPWQA28xKc+zMvYPtSyAD2GbMvYPxY8gSYJtZHOJ1lyWMD4EMYBsy9w7GiyFLAIDOBDIAgM4EMgCAzgQyAIDOBDIAgM4EMgCAzgQyAIDOBDIAgM4EMgCAzgQyAIDOBDIAgM4EMgCAzmwuDkyEw8fmcvDIiZw8NZ9d01OZ3bfb5tzAliGQAWPv8LG5HDh0PPOnzyRJ5k7N58Ch40kilAFbgiFLYOwdPHLirjC2aP70mRw8cqJTRQBnE8iAsXfy1Py62gFGTSADxt6u6al1tQOMmkAGjL3ZfbsztXPHWW1TO3dkdt/uThUBnM2kfmDsLU7cd5clsFUJZMBE2L9nRgADtixDlgAAnekhA+jMorXAUHvIqurxVXWiqm6pqmuWef2Hq+r2qrpp8PVjw6wHYKtZXLR27tR8Wu5etPbwsbnepQEjNLQesqrakeTFSf73JLcmeVdVXd9a+x/nHPq61tpzhlUHwEaNoudqtUVr9ZLB5BhmD9kjk9zSWvtga+3zSV6b5MlD/HkAm2ZUPVcWrQWS4QaymSQfWfL81kHbuf5FVb23ql5fVfcfYj3AmDh8bC5XXndDHnjNn+bK624YyvDeqLZbsmgtkAw3kNUybe2c53+c5LLW2jcl+Yskr1j2g6qurqqjVXX09ttv3+Qyge1k3HquLFoLJMMNZLcmWdrjdWmSk0sPaK39fWvtc4Onv5XkEct9UGvtpa21va21vZdccslQigW2h3Hrudq/ZybXXnVFZqanUklmpqdy7VVXmD8GE2aYy168K8nlVfXAJHNJnprkB5ceUFVf3Vq7bfD0SUneP8R6gDEwyp6rA4eOnxX+htVzZdFaYGiBrLV2Z1U9J8mRJDuSvKy1dnNVvSDJ0dba9Ul+sqqelOTOJJ9M8sPDqgcYD7umpzK3TPgaRs9VYrslYDSqtXOndW1te/fubUePHu1dBtDJ4hyyc3uuDPMBW1FV3dha23u+46zUD2wrW73nyqr7wEYIZMC2s1XnXJ3be7d4B2iSLVkvsHXYXBxgk4zqDlBg/AhkAJvEqvvARglkAJvEqvvARglkAJvEqvvARpnUD7BJtvodoMDWJZABbKKtegcosLUZsgQA6EwgAwDoTCADAOhMIAMA6EwgAwDoTCADAOjMshcAE+LwsTlrpMEWJZABTIDDx+Zy4NDxuzY/nzs1nwOHjieJUAZbgCFLgAlw8MiJu8LYovnTZ3LwyIlOFQFLCWQAE+Dkqfl1tQOjJZABTIBd01PragdGSyADmACz+3ZnaueOs9qmdu7I7L7dnSoCljKpH2ACLE7cd5clbE0CGcCE2L9nRgCDLcqQJQBAZwIZAEBnAhkAQGcCGQBAZwIZAEBnAhkAQGcCGQBAZ9YhA2BTHT42ZwFaWCeBDIAVrTdcHT42lwOHjmf+9Jkkydyp+Rw4dDxJhDJYhSFLAJa1GK7mTs2n5e5wdfjY3IrvOXjkxF1hbNH86TM5eOTEkKuF7U0gA2BZGwlXJ0/Nr6sdWCCQAbCsjYSrXdNT62oHFghkACxrI+Fqdt/uTO3ccVbb1M4dmd23e1Nrg3EjkAGwrI2Eq/17ZnLtVVdkZnoqlWRmeirXXnWFCf1wHu6yBGBZiyFqvUtY7N8zI4DBOglkAKxIuILREMgA2JYsQMs4EcgA2HYsQMu4MakfgG3HArSMG4EMgG3HArSMG0OWAGw7u6anMrdM+BrGArTmqjEKesgA2HZGtQDtRvbzhI0QyADYdka1AK25aoyKIUsAtqVRrJFmrhqjoocMAFZgs3RGRSADoLvDx+Zy5XU35IHX/GmuvO6GLTNHy2bpjIohSwC62sqLvG50P09YL4EMgK5Wmzi/2cFnI0tY2M+TURDIAOhqVBPnt3JPHJhDBkBXo5o4P8olLLbqnDi2LoEMgK5GNXF+1D1xFpNlPQQyALoa1SKv49gTx/gwhwyA7kYxcX523+6z5pAl27snjvGihwyAiTBuPXGMFz1kAEyMrdwTt5ElORgfAhkAbKKNLCZrSQ4EMgDYZOvtiRvl4rhsTQIZAHS20RsBDHOOD5P6AaCzjdwIYL2z8SKQAUBnG1kc13pn48WQJQB0tpEbAcZxvbNJHoIVyABgC1jvjQC7pqcyt0z42q7rnU36naaGLAFgGxrVHqCjMulDsHrIAGAb2sgw5yitd/hxHIdg10MgA4BtahQ7D2zERoYfx20Idr0MWQLABDl8bC5XXndDHnjNn+bK624YyjIZGxl+HLch2PXSQwYAE2JUE+c3Mvy40SHYcbkzUyADgAmx0S2a1ht6Njr8uN4h2I0GzK0Y4gxZAsCE2EjP1UZ2BBjV8ONGhka36g4HAhkATIiNbNG0kdCzf89Mrr3qisxMT6WSzExP5dqrrtj0XqiNBMyturyGIUsAmBCz+3afNcSXnL/naqPLUYziDtCNDI1u1eU19JABwITYSM/VRnrVRmUjQ6Nb9ffRQwYAE2S9PVcb6VUblY3cmblVfx+BDABY0VbfEWC9AXOr/j7VWutawHrt3bu3HT16tHcZAADnVVU3ttb2nu+4oc4hq6rHV9WJqrqlqq5Z5vV7VtXrBq+/o6ouG2Y9AABb0dACWVXtSPLiJE9I8pAkT6uqh5xz2I8m+YfW2tcneVGSXxlWPQAAW9Uwe8gemeSW1toHW2ufT/LaJE8+55gnJ3nF4PHrk3xXVdUQawIA2HKGGchmknxkyfNbB23LHtNauzPJHUnud+4HVdXVVXW0qo7efvvtQyoXAKCPYQay5Xq6zr2DYC3HpLX20tba3tba3ksuuWRTigMA2CqGGchuTXL/Jc8vTXJypWOq6qIk903yySHWBAAFSuedAAAHtklEQVSw5QwzkL0ryeVV9cCqukeSpya5/pxjrk/yzMHj709yQ9tu63AAAFygoS0M21q7s6qek+RIkh1JXtZau7mqXpDkaGvt+iS/k+S/VNUtWegZe+qw6gEA2KqGulJ/a+0NSd5wTtvzlzz+X0l+YJg1AABsdTYXBwDoTCADAOhMIAMA6EwgAwDoTCADAOhMIAMA6Ky22zqsVXV7kr8dwY+6OMknRvBztjLnwDlInIPEOUicg8Q5SJyDZP3n4Gtaa+fd93HbBbJRqaqjrbW9vevoyTlwDhLnIHEOEucgcQ4S5yAZ3jkwZAkA0JlABgDQmUC2spf2LmALcA6cg8Q5SJyDxDlInIPEOUiGdA7MIQMA6EwPGQBAZwLZOarq8VV1oqpuqapretfTQ1V9uKqOV9VNVXW0dz2jUFUvq6qPV9X7lrR9RVX9eVX9z8H3L+9Z47CtcA5+sarmBtfCTVX1xJ41DltV3b+q3lxV76+qm6vqpwbtE3MtrHIOJuZaqKp7VdU7q+o9g3Pw7wbtD6yqdwyug9dV1T161zosq5yDl1fVh5ZcBw/rXeuwVdWOqjpWVX8yeD6U60AgW6KqdiR5cZInJHlIkqdV1UP6VtXNd7bWHjZBtze/PMnjz2m7JsmbWmuXJ3nT4Pk4e3m++BwkyYsG18LDWmtvGHFNo3Znkue21h6c5FFJfmLwN2CSroWVzkEyOdfC55I8trX2zUkeluTxVfWoJL+ShXNweZJ/SPKjHWsctpXOQZLMLrkObupX4sj8VJL3L3k+lOtAIDvbI5Pc0lr7YGvt80lem+TJnWtiBFprb0nyyXOan5zkFYPHr0iyf6RFjdgK52CitNZua629e/D401n4IzyTCboWVjkHE6Mt+Mzg6c7BV0vy2CSvH7SP+3Ww0jmYKFV1aZLvSfLbg+eVIV0HAtnZZpJ8ZMnzWzNhf4gGWpI/q6obq+rq3sV09E9ba7clC/+TSvKVnevp5TlV9d7BkObYDtWdq6ouS7InyTsyodfCOecgmaBrYTBMdVOSjyf58yQfSHKqtXbn4JCx///DueegtbZ4Hfzy4Dp4UVXds2OJo/AfkjwvyRcGz++XIV0HAtnZapm2ifsXQZIrW2sPz8LQ7U9U1Xf0LohuXpLk67IwZHFbkl/rW85oVNW9k/xBkp9urX2qdz09LHMOJupaaK2daa09LMmlWRg9efByh422qtE69xxU1TcmOZDkQUm+JclXJPm3HUscqqr63iQfb63duLR5mUM35ToQyM52a5L7L3l+aZKTnWrpprV2cvD940n+MAt/jCbRx6rqq5Nk8P3jnesZudbaxwZ/lL+Q5LcyAddCVe3MQhB5VWvt0KB5oq6F5c7BJF4LSdJaO5XkL7Mwn266qi4avDQx/39Ycg4ePxjSbq21zyX53Yz3dXBlkidV1YezMIXpsVnoMRvKdSCQne1dSS4f3EFxjyRPTXJ955pGqqq+tKrus/g4yeOSvG/1d42t65M8c/D4mUn+qGMtXSyGkIF/njG/FgbzQ34nyftbay9c8tLEXAsrnYNJuhaq6pKqmh48nkry3VmYS/fmJN8/OGzcr4PlzsHfLPmHSWVh7tTYXgettQOttUtba5dlIQ/c0Fr7lxnSdWBh2HMMbuX+D0l2JHlZa+2XO5c0UlX1tVnoFUuSi5K8ehLOQVW9Jsljklyc5GNJfiHJ4SS/n+QBSf4uyQ+01sZ20vsK5+AxWRiiakk+nORZi3OpxlFVPTrJXyc5nrvnjPxsFuZQTcS1sMo5eFom5Fqoqm/KwmTtHVnouPj91toLBn8fX5uFobpjSZ4+6CkaO6ucgxuSXJKFobubkjx7yeT/sVVVj0nyf7XWvndY14FABgDQmSFLAIDOBDIAgM4EMgCAzgQyAIDOBDIAgM4EMmBbqqrPDL5fVlU/uMmf/bPnPP9vm/n5AOcSyIDt7rIk6wpkVbXjPIecFchaa//bOmsCWBeBDNjurkvy7VV1U1X9m8GGyAer6l2DDZCflSws7FhVb66qV2dh0dNU1eGqurGqbq6qqwdt1yWZGnzeqwZti71xNfjs91XV8ap6ypLP/suqen1V/U1VvWqwkjnAmlx0/kMAtrRrMlhBO0kGweqO1tq3VNU9k7ytqv5scOwjk3xja+1Dg+f/qrX2ycHWMO+qqj9orV1TVc8ZbKp8rquysFr9N2dhR4N3VdVbBq/tSfLQLOxr97Ys7IP31s3/dYFxpIcMGDePS/KMqropC1se3S/J5YPX3rkkjCXJT1bVe5K8Pcn9lxy3kkcnec1gk+2PJfmrJN+y5LNvHWy+fVMWhlIB1kQPGTBuKsm/bq0dOatxYS+6fzzn+Xcn+bbW2mer6i+T3GsNn72SpXvZnYm/r8A66CEDtrtPJ7nPkudHkvx4Ve1Mkqr6hqr60mXed98k/zAIYw9K8qglr51efP853pLkKYN5apck+Y4k79yU3wKYaP4FB2x3701y52Do8eVJ/mMWhgvfPZhYf3uS/cu8778meXZVvTfJiSwMWy56aZL3VtW7W2v/ckn7Hyb5tiTvSdKSPK+19tFBoAPYsGqt9a4BAGCiGbIEAOhMIAMA6EwgAwDoTCADAOhMIAMA6EwgAwDoTCADAOhMIAMA6Oz/B42PR1Zaxf8bAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# TODO: Use a three-layer Net to overfit 50 training examples by \n",
    "# tweaking just the learning rate and initialization scale.\n",
    "# 使用一个三层的网络，通过调整学习率和初始化scale来过拟合50个训练实例。\n",
    "num_train = 50\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "weight_scale = 1e-2   # Experiment with this!\n",
    "learning_rate = 8e-3  # Experiment with this!\n",
    "model = FullyConnectedNet([100, 100],\n",
    "              weight_scale=weight_scale, dtype=np.float64)\n",
    "solver = Solver(model, small_data,\n",
    "                print_every=10, num_epochs=20, batch_size=25,\n",
    "                update_rule='sgd',\n",
    "                optim_config={\n",
    "                  'learning_rate': learning_rate,\n",
    "                }\n",
    "         )\n",
    "solver.train()\n",
    "\n",
    "plt.plot(solver.loss_history, 'o')\n",
    "plt.title('Training loss history')\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Training loss')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now try to use a five-layer network with 100 units on each layer to overfit 50 training examples. \n",
    "\n",
    "Again, you will have to adjust the learning rate and weight initialization scale, but you should be able to achieve 100% training accuracy within 20 epochs.\n",
    "\n",
    "现在尝试使用一个五层的网络，每层100个单元，以过拟合50个训练的例子。\n",
    "\n",
    "同样，您将不得不调整学习速率和权重初始化scale，但是您应该能够在 20 epochs 内实现100%的训练精度。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 40) loss: 104.607207\n",
      "(Epoch 0 / 20) train acc: 0.140000; val_acc: 0.077000\n",
      "(Epoch 1 / 20) train acc: 0.140000; val_acc: 0.076000\n",
      "(Epoch 2 / 20) train acc: 0.160000; val_acc: 0.080000\n",
      "(Epoch 3 / 20) train acc: 0.200000; val_acc: 0.091000\n",
      "(Epoch 4 / 20) train acc: 0.340000; val_acc: 0.091000\n",
      "(Epoch 5 / 20) train acc: 0.320000; val_acc: 0.097000\n",
      "(Iteration 11 / 40) loss: 26.895924\n",
      "(Epoch 6 / 20) train acc: 0.480000; val_acc: 0.084000\n",
      "(Epoch 7 / 20) train acc: 0.540000; val_acc: 0.098000\n",
      "(Epoch 8 / 20) train acc: 0.560000; val_acc: 0.097000\n",
      "(Epoch 9 / 20) train acc: 0.660000; val_acc: 0.099000\n",
      "(Epoch 10 / 20) train acc: 0.640000; val_acc: 0.100000\n",
      "(Iteration 21 / 40) loss: 6.879619\n",
      "(Epoch 11 / 20) train acc: 0.720000; val_acc: 0.109000\n",
      "(Epoch 12 / 20) train acc: 0.660000; val_acc: 0.092000\n",
      "(Epoch 13 / 20) train acc: 0.720000; val_acc: 0.097000\n",
      "(Epoch 14 / 20) train acc: 0.760000; val_acc: 0.100000\n",
      "(Epoch 15 / 20) train acc: 0.720000; val_acc: 0.103000\n",
      "(Iteration 31 / 40) loss: 2.735954\n",
      "(Epoch 16 / 20) train acc: 0.780000; val_acc: 0.105000\n",
      "(Epoch 17 / 20) train acc: 0.780000; val_acc: 0.100000\n",
      "(Epoch 18 / 20) train acc: 0.880000; val_acc: 0.097000\n",
      "(Epoch 19 / 20) train acc: 0.900000; val_acc: 0.110000\n",
      "(Epoch 20 / 20) train acc: 0.920000; val_acc: 0.109000\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# TODO: Use a five-layer Net to overfit 50 training examples by \n",
    "# tweaking just the learning rate and initialization scale.\n",
    "# 使用一个五层的网络，通过调整学习速率和初始化scale来过拟合50个训练实例。\n",
    "num_train = 50\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "learning_rate = 9e-5  # Experiment with this!\n",
    "weight_scale = 1e-1   # Experiment with this!\n",
    "model = FullyConnectedNet([100, 100, 100, 100],\n",
    "                weight_scale=weight_scale, dtype=np.float64)\n",
    "solver = Solver(model, small_data,\n",
    "                print_every=10, num_epochs=20, batch_size=25,\n",
    "                update_rule='sgd',\n",
    "                optim_config={\n",
    "                  'learning_rate': learning_rate,\n",
    "                }\n",
    "         )\n",
    "solver.train()\n",
    "\n",
    "plt.plot(solver.loss_history, 'o')\n",
    "plt.title('Training loss history')\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Training loss')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "## Inline Question 2: \n",
    "Did you notice anything about the comparative difficulty of training the three-layer net vs training the five layer net? \n",
    "\n",
    "In particular, based on your experience, which network seemed more sensitive to the initialization scale? Why do you think that is the case?\n",
    "\n",
    "你注意到训练三层网络和训练五层网络的相对难度了吗?\n",
    "\n",
    "特别是，根据您的经验，哪个网络对初始化规模更敏感?为什么会这样呢?\n",
    "\n",
    "## Answer:\n",
    "[FILL THIS IN]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Update rules\n",
    "So far we have used vanilla stochastic gradient descent (SGD) as our update rule. \n",
    "\n",
    "More sophisticated update rules can make it easier to train deep networks. \n",
    "\n",
    "We will implement a few of the most commonly used update rules and compare them to vanilla SGD.\n",
    "\n",
    "到目前为止，我们已经使用了普通的随机梯度下降法(SGD)作为我们的更新规则。\n",
    "\n",
    "更复杂的更新规则可以更容易地训练深度网络。\n",
    "\n",
    "我们将实现一些最常用的更新规则，并将它们与普通的SGD进行比较。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SGD+Momentum\n",
    "Stochastic gradient descent with momentum is a widely used update rule that tends to make deep networks converge faster than vanilla stochastic gradient descent. \n",
    "\n",
    "See the Momentum Update section at http://cs231n.github.io/neural-networks-3/#sgd for more information.\n",
    "\n",
    "Open the file `cs231n/optim.py` and read the documentation at the top of the file to make sure you understand the API. \n",
    "\n",
    "Implement the SGD+momentum update rule in the function `sgd_momentum` and run the following to check your implementation. \n",
    "\n",
    "You should see errors less than e-8.\n",
    "\n",
    "**带动量的随机梯度下降法**是一种广泛使用的更新规则，它使深度网络的收敛速度快于**普通的随机梯度下降法**。\n",
    "\n",
    "有关更多信息，请参见http://cs231n.github.io/neural-networks-3/#sgd 的动量更新部分。\n",
    "\n",
    "打开文件`cs231n/optim.py`，并阅读文件顶部的文档，以确保您理解了该API。\n",
    "\n",
    "在函数`sgd_momentum`中实现**随机梯度下降+动量**更新规则，并运行以下命令检查实现。\n",
    "\n",
    "你会看到误差小于e-8。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "next_w error:  8.882347033505819e-09\n",
      "velocity error:  4.269287743278663e-09\n"
     ]
    }
   ],
   "source": [
    "from cs231n.optim import sgd_momentum\n",
    "\n",
    "N, D = 4, 5\n",
    "w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n",
    "dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n",
    "v = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n",
    "\n",
    "config = {'learning_rate': 1e-3, 'velocity': v}\n",
    "next_w, _ = sgd_momentum(w, dw, config=config)\n",
    "\n",
    "expected_next_w = np.asarray([\n",
    "  [ 0.1406,      0.20738947,  0.27417895,  0.34096842,  0.40775789],\n",
    "  [ 0.47454737,  0.54133684,  0.60812632,  0.67491579,  0.74170526],\n",
    "  [ 0.80849474,  0.87528421,  0.94207368,  1.00886316,  1.07565263],\n",
    "  [ 1.14244211,  1.20923158,  1.27602105,  1.34281053,  1.4096    ]])\n",
    "expected_velocity = np.asarray([\n",
    "  [ 0.5406,      0.55475789,  0.56891579, 0.58307368,  0.59723158],\n",
    "  [ 0.61138947,  0.62554737,  0.63970526,  0.65386316,  0.66802105],\n",
    "  [ 0.68217895,  0.69633684,  0.71049474,  0.72465263,  0.73881053],\n",
    "  [ 0.75296842,  0.76712632,  0.78128421,  0.79544211,  0.8096    ]])\n",
    "\n",
    "# Should see relative errors around e-8 or less\n",
    "print('next_w error: ', rel_error(next_w, expected_next_w))\n",
    "print('velocity error: ', rel_error(expected_velocity, config['velocity']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you have done so, run the following to train a six-layer network with both SGD and SGD+momentum. \n",
    "\n",
    "You should see the SGD+momentum update rule converge faster.\n",
    "\n",
    "一旦你这样做了，运行以下来训练一个具有SGD和SGD+动量的六层网络。\n",
    "\n",
    "你应该看到SGD+动量更新规则收敛得更快。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "running with  sgd\n",
      "(Iteration 1 / 200) loss: 2.678863\n",
      "(Epoch 0 / 5) train acc: 0.110000; val_acc: 0.111000\n",
      "(Iteration 11 / 200) loss: 2.274933\n",
      "(Iteration 21 / 200) loss: 2.175633\n",
      "(Iteration 31 / 200) loss: 2.097040\n",
      "(Epoch 1 / 5) train acc: 0.256000; val_acc: 0.220000\n",
      "(Iteration 41 / 200) loss: 2.107710\n",
      "(Iteration 51 / 200) loss: 2.160821\n",
      "(Iteration 61 / 200) loss: 1.951037\n",
      "(Iteration 71 / 200) loss: 1.886787\n",
      "(Epoch 2 / 5) train acc: 0.323000; val_acc: 0.248000\n",
      "(Iteration 81 / 200) loss: 2.126963\n",
      "(Iteration 91 / 200) loss: 1.867634\n",
      "(Iteration 101 / 200) loss: 1.948371\n",
      "(Iteration 111 / 200) loss: 1.838423\n",
      "(Epoch 3 / 5) train acc: 0.289000; val_acc: 0.257000\n",
      "(Iteration 121 / 200) loss: 1.941790\n",
      "(Iteration 131 / 200) loss: 1.820515\n",
      "(Iteration 141 / 200) loss: 1.865708\n",
      "(Iteration 151 / 200) loss: 1.838643\n",
      "(Epoch 4 / 5) train acc: 0.349000; val_acc: 0.279000\n",
      "(Iteration 161 / 200) loss: 1.900360\n",
      "(Iteration 171 / 200) loss: 1.911193\n",
      "(Iteration 181 / 200) loss: 1.806372\n",
      "(Iteration 191 / 200) loss: 1.770945\n",
      "(Epoch 5 / 5) train acc: 0.393000; val_acc: 0.302000\n",
      "\n",
      "running with  sgd_momentum\n",
      "(Iteration 1 / 200) loss: 2.538737\n",
      "(Epoch 0 / 5) train acc: 0.089000; val_acc: 0.108000\n",
      "(Iteration 11 / 200) loss: 2.246057\n",
      "(Iteration 21 / 200) loss: 1.938190\n",
      "(Iteration 31 / 200) loss: 2.039141\n",
      "(Epoch 1 / 5) train acc: 0.273000; val_acc: 0.283000\n",
      "(Iteration 41 / 200) loss: 1.843922\n",
      "(Iteration 51 / 200) loss: 1.839416\n",
      "(Iteration 61 / 200) loss: 1.866181\n",
      "(Iteration 71 / 200) loss: 1.700396\n",
      "(Epoch 2 / 5) train acc: 0.413000; val_acc: 0.327000\n",
      "(Iteration 81 / 200) loss: 1.570451\n",
      "(Iteration 91 / 200) loss: 1.676678\n",
      "(Iteration 101 / 200) loss: 1.497220\n",
      "(Iteration 111 / 200) loss: 1.660993\n",
      "(Epoch 3 / 5) train acc: 0.464000; val_acc: 0.322000\n",
      "(Iteration 121 / 200) loss: 1.412020\n",
      "(Iteration 131 / 200) loss: 1.492627\n",
      "(Iteration 141 / 200) loss: 1.497802\n",
      "(Iteration 151 / 200) loss: 1.288794\n",
      "(Epoch 4 / 5) train acc: 0.511000; val_acc: 0.356000\n",
      "(Iteration 161 / 200) loss: 1.372296\n",
      "(Iteration 171 / 200) loss: 1.213638\n",
      "(Iteration 181 / 200) loss: 1.270836\n",
      "(Iteration 191 / 200) loss: 1.391405\n",
      "(Epoch 5 / 5) train acc: 0.558000; val_acc: 0.370000\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\anacondathree\\lib\\site-packages\\matplotlib\\figure.py:98: MatplotlibDeprecationWarning: \n",
      "Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "  \"Adding an axes using the same arguments as a previous axes \"\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "num_train = 4000\n",
    "small_data = {\n",
    "    'X_train': data['X_train'][:num_train],\n",
    "    'y_train': data['y_train'][:num_train],\n",
    "    'X_val': data['X_val'],\n",
    "    'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "solvers = {}\n",
    "\n",
    "for update_rule in ['sgd', 'sgd_momentum']:\n",
    "    print('running with ', update_rule)\n",
    "    model = FullyConnectedNet([100, 100, 100, 100, 100], weight_scale=5e-2)\n",
    "\n",
    "    solver = Solver(model, small_data,\n",
    "                    num_epochs=5, batch_size=100,\n",
    "                    update_rule=update_rule,\n",
    "                    optim_config={\n",
    "                        'learning_rate': 5e-3,\n",
    "                    },\n",
    "                    verbose=True)\n",
    "    solvers[update_rule] = solver\n",
    "    solver.train()\n",
    "    print()\n",
    "\n",
    "plt.subplot(3, 1, 1)\n",
    "plt.title('Training loss')\n",
    "plt.xlabel('Iteration')\n",
    "\n",
    "plt.subplot(3, 1, 2)\n",
    "plt.title('Training accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "plt.subplot(3, 1, 3)\n",
    "plt.title('Validation accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "for update_rule, solver in solvers.items():\n",
    "    plt.subplot(3, 1, 1)\n",
    "    plt.plot(solver.loss_history, 'o', label=\"loss_%s\" % update_rule)\n",
    "\n",
    "    plt.subplot(3, 1, 2)\n",
    "    plt.plot(solver.train_acc_history, '-o',\n",
    "             label=\"train_acc_%s\" % update_rule)\n",
    "\n",
    "    plt.subplot(3, 1, 3)\n",
    "    plt.plot(solver.val_acc_history, '-o', label=\"val_acc_%s\" % update_rule)\n",
    "\n",
    "for i in [1, 2, 3]:\n",
    "    plt.subplot(3, 1, i)\n",
    "    plt.legend(loc='upper center', ncol=4)\n",
    "plt.gcf().set_size_inches(15, 15)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# RMSProp and Adam\n",
    "RMSProp [1] and Adam [2] are update rules that set per-parameter learning rates by using a running average of the second moments of gradients.\n",
    "\n",
    "In the file `cs231n/optim.py`, implement the RMSProp update rule in the `rmsprop` function and implement the Adam update rule in the `adam` function, and check your implementations using the tests below.\n",
    "RMSProp[1]和Adam[2]是更新规则，它们通过使用梯度的第二个时刻的运行平均值来设置每个参数的学习速率。\n",
    "\n",
    "在文件`cs231n/optim.py`中。在`rmsprop`函数中实现RMSProp更新规则，在`adam`函数中实现Adam更新规则，并使用下面的测试来检查您的实现。\n",
    "\n",
    "**NOTE:** Please implement the _complete_ Adam update rule (with the bias correction mechanism), not the first simplified version mentioned in the course notes. \n",
    "\n",
    "注意:请执行完整的Adam更新规则(带有bias纠正机制)，而不是课程笔记中提到的第一个简化版本。\n",
    "\n",
    "[1] Tijmen Tieleman and Geoffrey Hinton. \"Lecture 6.5-rmsprop: Divide the gradient by a running average of its recent magnitude.\" COURSERA: Neural Networks for Machine Learning 4 (2012).\n",
    "\n",
    "[2] Diederik Kingma and Jimmy Ba, \"Adam: A Method for Stochastic Optimization\", ICLR 2015."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "next_w error:  9.524687511038133e-08\n",
      "cache error:  2.6477955807156126e-09\n"
     ]
    }
   ],
   "source": [
    "# Test RMSProp implementation\n",
    "from cs231n.optim import rmsprop\n",
    "\n",
    "N, D = 4, 5\n",
    "w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n",
    "dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n",
    "cache = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n",
    "\n",
    "config = {'learning_rate': 1e-2, 'cache': cache}\n",
    "next_w, _ = rmsprop(w, dw, config=config)\n",
    "\n",
    "expected_next_w = np.asarray([\n",
    "  [-0.39223849, -0.34037513, -0.28849239, -0.23659121, -0.18467247],\n",
    "  [-0.132737,   -0.08078555, -0.02881884,  0.02316247,  0.07515774],\n",
    "  [ 0.12716641,  0.17918792,  0.23122175,  0.28326742,  0.33532447],\n",
    "  [ 0.38739248,  0.43947102,  0.49155973,  0.54365823,  0.59576619]])\n",
    "expected_cache = np.asarray([\n",
    "  [ 0.5976,      0.6126277,   0.6277108,   0.64284931,  0.65804321],\n",
    "  [ 0.67329252,  0.68859723,  0.70395734,  0.71937285,  0.73484377],\n",
    "  [ 0.75037008,  0.7659518,   0.78158892,  0.79728144,  0.81302936],\n",
    "  [ 0.82883269,  0.84469141,  0.86060554,  0.87657507,  0.8926    ]])\n",
    "\n",
    "# You should see relative errors around e-7 or less\n",
    "print('next_w error: ', rel_error(expected_next_w, next_w))\n",
    "print('cache error: ', rel_error(expected_cache, config['cache']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "next_w error:  1.1355763428905147e-07\n",
      "v error:  4.208314038113071e-09\n",
      "m error:  4.214963193114416e-09\n"
     ]
    }
   ],
   "source": [
    "# Test Adam implementation\n",
    "from cs231n.optim import adam\n",
    "\n",
    "N, D = 4, 5\n",
    "w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n",
    "dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n",
    "m = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n",
    "v = np.linspace(0.7, 0.5, num=N*D).reshape(N, D)\n",
    "\n",
    "config = {'learning_rate': 1e-2, 'm': m, 'v': v, 't': 5}\n",
    "next_w, _ = adam(w, dw, config=config)\n",
    "\n",
    "expected_next_w = np.asarray([\n",
    "  [-0.40094747, -0.34836187, -0.29577703, -0.24319299, -0.19060977],\n",
    "  [-0.1380274,  -0.08544591, -0.03286534,  0.01971428,  0.0722929],\n",
    "  [ 0.1248705,   0.17744702,  0.23002243,  0.28259667,  0.33516969],\n",
    "  [ 0.38774145,  0.44031188,  0.49288093,  0.54544852,  0.59801459]])\n",
    "expected_v = np.asarray([\n",
    "  [ 0.69966,     0.68908382,  0.67851319,  0.66794809,  0.65738853,],\n",
    "  [ 0.64683452,  0.63628604,  0.6257431,   0.61520571,  0.60467385,],\n",
    "  [ 0.59414753,  0.58362676,  0.57311152,  0.56260183,  0.55209767,],\n",
    "  [ 0.54159906,  0.53110598,  0.52061845,  0.51013645,  0.49966,   ]])\n",
    "expected_m = np.asarray([\n",
    "  [ 0.48,        0.49947368,  0.51894737,  0.53842105,  0.55789474],\n",
    "  [ 0.57736842,  0.59684211,  0.61631579,  0.63578947,  0.65526316],\n",
    "  [ 0.67473684,  0.69421053,  0.71368421,  0.73315789,  0.75263158],\n",
    "  [ 0.77210526,  0.79157895,  0.81105263,  0.83052632,  0.85      ]])\n",
    "\n",
    "# You should see relative errors around e-7 or less\n",
    "print('next_w error: ', rel_error(expected_next_w, next_w))\n",
    "print('v error: ', rel_error(expected_v, config['v']))\n",
    "print('m error: ', rel_error(expected_m, config['m']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you have debugged your RMSProp and Adam implementations, run the following to train a pair of deep networks using these new update rules:\n",
    "\n",
    "一旦你调试了你的RMSProp和Adam实现，运行下面的代码来使用这些新的更新规则来训练一对深层网络:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "running with  adam\n",
      "(Iteration 1 / 200) loss: 2.793229\n",
      "(Epoch 0 / 5) train acc: 0.116000; val_acc: 0.141000\n",
      "(Iteration 11 / 200) loss: 1.990817\n",
      "(Iteration 21 / 200) loss: 2.002982\n",
      "(Iteration 31 / 200) loss: 1.750460\n",
      "(Epoch 1 / 5) train acc: 0.347000; val_acc: 0.291000\n",
      "(Iteration 41 / 200) loss: 1.824369\n",
      "(Iteration 51 / 200) loss: 1.780843\n",
      "(Iteration 61 / 200) loss: 1.601907\n",
      "(Iteration 71 / 200) loss: 1.709919\n",
      "(Epoch 2 / 5) train acc: 0.451000; val_acc: 0.361000\n",
      "(Iteration 81 / 200) loss: 1.481537\n",
      "(Iteration 91 / 200) loss: 1.383479\n",
      "(Iteration 101 / 200) loss: 1.383171\n",
      "(Iteration 111 / 200) loss: 1.475382\n",
      "(Epoch 3 / 5) train acc: 0.482000; val_acc: 0.340000\n",
      "(Iteration 121 / 200) loss: 1.447891\n",
      "(Iteration 131 / 200) loss: 1.358982\n",
      "(Iteration 141 / 200) loss: 1.376147\n",
      "(Iteration 151 / 200) loss: 1.290640\n",
      "(Epoch 4 / 5) train acc: 0.525000; val_acc: 0.368000\n",
      "(Iteration 161 / 200) loss: 1.263474\n",
      "(Iteration 171 / 200) loss: 1.330028\n",
      "(Iteration 181 / 200) loss: 1.374226\n",
      "(Iteration 191 / 200) loss: 1.394842\n",
      "(Epoch 5 / 5) train acc: 0.580000; val_acc: 0.373000\n",
      "\n",
      "running with  rmsprop\n",
      "(Iteration 1 / 200) loss: 2.844246\n",
      "(Epoch 0 / 5) train acc: 0.158000; val_acc: 0.137000\n",
      "(Iteration 11 / 200) loss: 2.014835\n",
      "(Iteration 21 / 200) loss: 1.968562\n",
      "(Iteration 31 / 200) loss: 1.875444\n",
      "(Epoch 1 / 5) train acc: 0.371000; val_acc: 0.291000\n",
      "(Iteration 41 / 200) loss: 1.832866\n",
      "(Iteration 51 / 200) loss: 1.833353\n",
      "(Iteration 61 / 200) loss: 1.753256\n",
      "(Iteration 71 / 200) loss: 1.567502\n",
      "(Epoch 2 / 5) train acc: 0.434000; val_acc: 0.337000\n",
      "(Iteration 81 / 200) loss: 1.634675\n",
      "(Iteration 91 / 200) loss: 1.600141\n",
      "(Iteration 101 / 200) loss: 1.597020\n",
      "(Iteration 111 / 200) loss: 1.541348\n",
      "(Epoch 3 / 5) train acc: 0.442000; val_acc: 0.332000\n",
      "(Iteration 121 / 200) loss: 1.646407\n",
      "(Iteration 131 / 200) loss: 1.462662\n",
      "(Iteration 141 / 200) loss: 1.477135\n",
      "(Iteration 151 / 200) loss: 1.614231\n",
      "(Epoch 4 / 5) train acc: 0.542000; val_acc: 0.353000\n",
      "(Iteration 161 / 200) loss: 1.352557\n",
      "(Iteration 171 / 200) loss: 1.387404\n",
      "(Iteration 181 / 200) loss: 1.438874\n",
      "(Iteration 191 / 200) loss: 1.213007\n",
      "(Epoch 5 / 5) train acc: 0.500000; val_acc: 0.354000\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "learning_rates = {'rmsprop': 1e-4, 'adam': 1e-3}\n",
    "for update_rule in ['adam', 'rmsprop']:\n",
    "    print('running with ', update_rule)\n",
    "    model = FullyConnectedNet([100, 100, 100, 100, 100], weight_scale=5e-2)\n",
    "\n",
    "    solver = Solver(model, small_data,\n",
    "                    num_epochs=5, batch_size=100,\n",
    "                    update_rule=update_rule,\n",
    "                    optim_config={\n",
    "                        'learning_rate': learning_rates[update_rule]\n",
    "                    },\n",
    "                    verbose=True)\n",
    "    solvers[update_rule] = solver\n",
    "    solver.train()\n",
    "    print()\n",
    "\n",
    "plt.subplot(3, 1, 1)\n",
    "plt.title('Training loss')\n",
    "plt.xlabel('Iteration')\n",
    "\n",
    "plt.subplot(3, 1, 2)\n",
    "plt.title('Training accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "plt.subplot(3, 1, 3)\n",
    "plt.title('Validation accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "for update_rule, solver in list(solvers.items()):\n",
    "    plt.subplot(3, 1, 1)\n",
    "    plt.plot(solver.loss_history, 'o', label=update_rule)\n",
    "\n",
    "    plt.subplot(3, 1, 2)\n",
    "    plt.plot(solver.train_acc_history, '-o', label=update_rule)\n",
    "\n",
    "    plt.subplot(3, 1, 3)\n",
    "    plt.plot(solver.val_acc_history, '-o', label=update_rule)\n",
    "\n",
    "for i in [1, 2, 3]:\n",
    "    plt.subplot(3, 1, i)\n",
    "    plt.legend(loc='upper center', ncol=4)\n",
    "plt.gcf().set_size_inches(15, 15)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "## Inline Question 3:\n",
    "\n",
    "AdaGrad, like Adam, is a per-parameter optimization method that uses the following update rule:\n",
    "AdaGrad，和Adam一样，是一个每参数优化方法，它使用以下更新规则:\n",
    "\n",
    "```\n",
    "cache += dw**2\n",
    "w += - learning_rate * dw / (np.sqrt(cache) + eps)\n",
    "```\n",
    "\n",
    "John notices that when he was training a network with AdaGrad that the updates became very small, and that his network was learning slowly. \n",
    "\n",
    "Using your knowledge of the AdaGrad update rule, why do you think the updates would become very small? Would Adam have the same issue?\n",
    "\n",
    "John注意到，当他使用AdaGrad训练一个网络时，更新变得非常小，他的网络正在缓慢地学习。\n",
    "\n",
    "利用您对AdaGrad更新规则的了解，为什么您认为更新会变得非常小?Adam会有同样的问题吗?\n",
    "\n",
    "## Answer: \n",
    "[FILL THIS IN]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train a good model!\n",
    "Train the best fully-connected model that you can on CIFAR-10, storing your best model in the `best_model` variable. \n",
    "\n",
    "We require you to get at least 50% accuracy on the validation set using a fully-connected net.\n",
    "\n",
    "If you are careful it should be possible to get accuracies above 55%, but we don't require it for this part and won't assign extra credit for doing so. \n",
    "\n",
    "Later in the assignment we will ask you to train the best convolutional network that you can on CIFAR-10, and we would prefer that you spend your effort working on convolutional nets rather than fully-connected nets.\n",
    "\n",
    "You might find it useful to complete the `BatchNormalization.ipynb` and `Dropout.ipynb` notebooks before completing this part, since those techniques can help you train powerful models.\n",
    "\n",
    "在CIFAR-10上训练最好的全连接模型，将最好的模型存储在`best_model`变量中。\n",
    "\n",
    "我们要求您在使用全网连接的验证集上获得至少50%的准确性。\n",
    "\n",
    "如果你小心，它应该是有可能得到精度55%以上，但我们在这部分不要求，也不会因为这样做而分配额外的学分。\n",
    "\n",
    "在作业的后面，我们会要求你们在CIFAR-10上尽可能地训练最好的卷积网络，我们希望你们把精力放在卷积网络上，而不是全连接网络上。\n",
    "\n",
    "您可能会发现在完成这部分之前完成`BatchNormalization.ipynb`和`Dropout.ipynb`笔记本非常有用。因为这些技术可以帮助您训练强大的模型。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "best_model = None\n",
    "################################################################################\n",
    "# TODO: Train the best FullyConnectedNet that you can on CIFAR-10. You might   #\n",
    "# find batch/layer normalization and dropout useful. Store your best model in  #\n",
    "# the best_model variable.                                                     #\n",
    "################################################################################\n",
    "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "# 在CIFAR-10上尽可能训练最好的全连接网络。\n",
    "# 您可能会发现batch/layer normalization和dropout很有用。\n",
    "# 将您的最佳模型存储在best_model变量中。\n",
    "pass\n",
    "\n",
    "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "################################################################################\n",
    "#                              END OF YOUR CODE                                #\n",
    "################################################################################"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Test your model!\n",
    "Run your best model on the validation and test sets. \n",
    "\n",
    "You should achieve above 50% accuracy on the validation set.\n",
    "\n",
    "在验证和测试集上运行您的最佳模型。\n",
    "\n",
    "验证集的准确率应达到50%以上。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_test_pred = np.argmax(best_model.loss(data['X_test']), axis=1)\n",
    "y_val_pred = np.argmax(best_model.loss(data['X_val']), axis=1)\n",
    "print('Validation set accuracy: ', (y_val_pred == data['y_val']).mean())\n",
    "print('Test set accuracy: ', (y_test_pred == data['y_test']).mean())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "position": {
    "height": "478px",
    "left": "1233px",
    "right": "20px",
    "top": "120px",
    "width": "283px"
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
